/**
 * 
 */
package it.agm.fanta.asynctask.util;

import it.agm.activity.dialog.GenericDialog;
import it.agm.fanta.FantaserviceApp;
import it.agm.fanta.asynctask.jersey.patch.Callback;
import it.agm.fanta.asynctask.jersey.patch.NetworkHandler;
import it.agm.fanta.constants.Constants;
import it.agm.fanta.model.FormazioneLegaRead;
import it.agm.fanta.model.Giocatore;
import it.agm.fanta.model.Marcatore;
import it.agm.fanta.model.Partita;
import it.agm.fanta.model.Partite;
import it.agm.fanta.model.Squadra;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

/**
 * @author alberto
 *
 */
public class SyncUtility {
	
	public static final String ERRORE_DI_CONNESSIONE = "Errore di connessione\nConnessione ad internet assente";
	/**
	 * 
	 */
	public static void syncForLega(Context ctx) {
		if(isConnectionPresent(ctx)){
			
			NetworkHandler networkHandler = NetworkHandler.getInstance();
			syncLega(networkHandler);
			syncInfoLega(networkHandler);
//			String url = Constants.URL_REST 	+ Constants.SERVICE_COPPA_CLASSIFICA;
			syncInfoCoppa(networkHandler);
			syncClassificaMarcatori(networkHandler);
			syncRosa(networkHandler);
			
			syncFormazione(networkHandler, ctx);
		}else{
			new GenericDialog(FantaserviceApp.currentActivity(), ERRORE_DI_CONNESSIONE,"ERROR");
		}
	}

	/**
	 * @param networkHandler
	 */
	public static void syncInfoLega(NetworkHandler networkHandler) {
		syncClassifica(networkHandler);
		syncCalendario(networkHandler);
	}

	/**
	 * @param networkHandler
	 */
	private static void syncClassifica(NetworkHandler networkHandler) {
		String url = Constants.URL_REST 	+ Constants.SERVICE_CLASSIFICA;
		networkHandler.write(url, Squadra[].class, FantaserviceApp.squadre,
			new Callback<Squadra[]>() {
				@Override
				public void callback(Squadra[] squadre) {
					FantaserviceApp.squadre = squadre;
				}
			});
	}

	/**
	 * @param networkHandler
	 */
	public static void syncInfoCoppa(NetworkHandler networkHandler) {
		syncSquadreCoppa(networkHandler);
		syncCalendarioCoppa(networkHandler);
		syncClassificaCoppa(networkHandler);
	}

	/**
	 * @param networkHandler
	 */
	public static void syncClassificaCoppa(NetworkHandler networkHandler) {
		String url;
		FantaserviceApp.request.setGiornataincorso(false);
		url = Constants.URL_REST 	+ Constants.SERVICE_COPPA_CLASSIFICA;
		
		networkHandler.write(url, Squadra[].class, FantaserviceApp.squadreCoppa,
			new Callback<Squadra[]>() {
				@Override
				public void callback(Squadra[] squadre) {
					List<Squadra> arrayListSquadra = new ArrayList<Squadra>();
					
					for(int i=0; i<squadre.length ;i++){
						arrayListSquadra.add(squadre[i]);
					}
					for (Iterator<Squadra> iterator = arrayListSquadra.iterator(); iterator.hasNext();) {
						Squadra squadraCoppa = iterator.next();
						if(!FantaserviceApp.squadreGironeCoppa.contains(squadraCoppa.getNomesquadra())){
							  iterator.remove();
						}
					}
					FantaserviceApp.squadreCoppa = new Squadra[arrayListSquadra.size()];
					arrayListSquadra.toArray(FantaserviceApp.squadreCoppa);
					
				}
			});
		
	}

	
	/**
	 * @param networkHandler
	 */
	public static void syncFormazione(NetworkHandler networkHandler,Context ctx) {
		String url;
		FantaserviceApp.request.setGiornataincorso(false);
		url = Constants.URL_REST 	+ Constants.SERVICE_FORMAZIONE;
		FormazioneLegaRead[] formazione = null ;
		
		FantaserviceApp.formazioneReaded = null;
		if(isConnectionPresent(ctx)){
			networkHandler.write(url, FormazioneLegaRead[].class, formazione,
				new Callback<FormazioneLegaRead[]>() {
					@Override
					public void callback(FormazioneLegaRead[] formazione) {
						if(formazione != null && formazione.length>0){
							List<Giocatore> list = formazione[0].getCalciatoreFormazioneLega();
							FantaserviceApp.dettaglio = formazione[0].getDettaglioFormazioneLega();
							FantaserviceApp.formazioneReaded= (ArrayList<Giocatore>) list;
						}
						
					}
				});
		}
	}

	/**
	 * @param networkHandler
	 */
	public static void syncCalendario(NetworkHandler networkHandler) {
		String url = Constants.URL_REST ;
//		if(FantaserviceApp.request != null && FantaserviceApp.request.isCoppa()){
//			url +=  Constants.SERVICE_GIORNATA_COPPA_LEGA;
//		}else{
			url += Constants.SERVICE_GIORNATA_LEGA;
//		}
		Partite[] partiteCorrentiTmp = null ;
		//FantaserviceApp.request.setGiornataincorso(true);
		networkHandler.write(url, Partite[].class, partiteCorrentiTmp,
				new Callback<Partite[]>() {
					@Override
					public void callback(Partite partite[]) {
						FantaserviceApp.partite = partite[0];
						for (Partita partita : FantaserviceApp.partite.getPartite()) {
							if(partita.getSquadracasa().equals(FantaserviceApp.lega.getNomesquadra())
									|| partita.getSquadratrasferta().equals(FantaserviceApp.lega.getNomesquadra())){
								FantaserviceApp.partitaLive = partita;
								break;
							}
						}
						if(FantaserviceApp.calendarioFragment != null){
//							FantaserviceApp.calendarioFragment.refrash();
						}
					}
				});
	}

	/**
	 * @param networkHandler
	 */
	public static void syncCalendarioCoppa(NetworkHandler networkHandler) {
		String url = Constants.URL_REST ;
			url +=  Constants.SERVICE_GIORNATA_COPPA_LEGA;
		Partite[] partiteCorrentiTmp = null ;
		networkHandler.write(url, Partite[].class, partiteCorrentiTmp,
				new Callback<Partite[]>() {
					@Override
					public void callback(Partite partite[]) {
						FantaserviceApp.partiteCoppa = partite[0];
						for (Iterator<Partita> iterator = FantaserviceApp.partiteCoppa.getPartite().iterator(); iterator.hasNext();) {
							Partita partita = iterator.next();
							if((!FantaserviceApp.squadreGironeCoppa.contains(partita.getSquadracasa()) 
									&& !FantaserviceApp.squadreGironeCoppa.contains(partita.getSquadratrasferta())
									&& "CoppaLega Fase1".equals(partita.getFase()))){
								  iterator.remove();
							}
							
						}
						for (Partita partita : FantaserviceApp.partiteCoppa.getPartite()) {
							if(partita.getSquadracasa().equals(FantaserviceApp.lega.getNomesquadra())
									|| partita.getSquadratrasferta().equals(FantaserviceApp.lega.getNomesquadra())){
								FantaserviceApp.partitaCoppaLive = partita;
								
								break;
							}
						}
						if(FantaserviceApp.calendarioFragment != null){
//							FantaserviceApp.calendarioFragment.refrash();
						}
					}
				});
	}
	
	/**
	 * @param networkHandler
	 */
	public static void syncSquadreCoppa(NetworkHandler networkHandler) {
		String url = Constants.URL_REST ;
		url +=  Constants.SERVICE_GIORNATA_COPPA_LEGA;
		Partite[] partiteCorrentiTmp = null ;
		networkHandler.write(url, Partite[].class, partiteCorrentiTmp,
				new Callback<Partite[]>() {
					@Override
					public void callback(Partite partite[]) {
						FantaserviceApp.partiteCoppa = partite[0];
						FantaserviceApp.squadreGironeCoppa = new ArrayList<String>();
						FantaserviceApp.squadreGironeCoppa.add(FantaserviceApp.lega.getNomesquadra());
						for (Partita partita : FantaserviceApp.partiteCoppa.getPartite()) {
							if(partita.getSquadracasa().equals(FantaserviceApp.lega.getNomesquadra())){
//									|| partita.getSquadratrasferta().equals(FantaserviceApp.lega.getNomesquadra())){
								if(FantaserviceApp.squadreGironeCoppa!=null && !FantaserviceApp.squadreGironeCoppa.contains(partita.getSquadratrasferta())){
									FantaserviceApp.squadreGironeCoppa.add(partita.getSquadratrasferta());
									
								}
							}	
						}
						
					}
				});
	}


	
	/**
	 * @param networkHandler
	 */
	public static void syncRosa(NetworkHandler networkHandler) {
		String url;
		url = Constants.URL_REST 	+ Constants.SERVICE_ROSA;
		Giocatore[] giocatoriTmp = null ;
		networkHandler.write(url, Giocatore[].class, giocatoriTmp,
				new Callback<Giocatore[]>() {
					@Override
					public void callback(Giocatore giocatori[]) {
						ArrayList<Giocatore> list = new ArrayList<Giocatore>();
						list = new ArrayList<Giocatore>(Arrays.asList(giocatori));
						FantaserviceApp.rosa = list;
						
					}
				});
	}

	/**
	 * @param networkHandler
	 */
	public static void syncClassificaMarcatori(NetworkHandler networkHandler) {
		String url;
		url = Constants.URL_REST 	+ Constants.SERVICE_FANTA_MARCATORI;
		Marcatore[] marcatoriTmp = null ;
		networkHandler.write(url, Marcatore[].class, marcatoriTmp,
				new Callback<Marcatore[]>() {
					@Override
					public void callback(Marcatore marcatori[]) {
						ArrayList<Marcatore> list = new ArrayList<Marcatore>();
						list = new ArrayList<Marcatore>(Arrays.asList(marcatori));
						FantaserviceApp.marcatori = list;
						
					}
				});
	}

	/**
	 * @param networkHandler
	 */
	public static void syncLega(NetworkHandler networkHandler) {
		String url;
		url = Constants.URL_REST 	+ Constants.SERVICE_GIORNATA_LEGA;
		Partite[] partiteTmp = null ;
		networkHandler.write(url, Partite[].class, partiteTmp,
				new Callback<Partite[]>() {
					@Override
					public void callback(Partite partite[]) {
						FantaserviceApp.partite = partite[0];
					}
				});
	}
	
	/**
	 * Metodo che verifica la presenza della connesisone a internet
	 * @param ctx
	 * @return
	 */
	public static boolean isConnectionPresent(Context ctx){
		ConnectivityManager conMgr = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo i = conMgr.getActiveNetworkInfo();
		boolean retval = false;
		if (i == null){
			retval = false;
		}else if (!i.isConnected()){
			retval = false;
		}else if (!i.isAvailable()){
			retval = false;
		}else{
			retval = true;
		}
		return retval;
	}
}
